/**
 * 检查缺失物品脚本
 * 功能：比较JSON文件和数据库表，找出缺失的物品
 */

const mysql = require('mysql2/promise');
const fs = require('fs');
const path = require('path');

// 数据库连接配置（硬编码）
const DB_CONFIG = {
    host: '43.143.253.188',
    port: 3306,
    user: 'nextjs',
    password: 'yEAiRE2jcxTyRBy5',
    database: 'nextjs',
    charset: 'utf8mb4'
};

class MissingItemChecker {
    constructor() {
        this.connection = null;
        this.jsonData = null;
    }

    // 连接数据库
    async connectDatabase() {
        try {
            console.log('🔌 正在连接数据库...');
            this.connection = await mysql.createConnection(DB_CONFIG);
            console.log('✅ 数据库连接成功');
        } catch (error) {
            console.error('❌ 数据库连接失败:', error.message);
            throw error;
        }
    }

    // 关闭数据库连接
    async closeDatabase() {
        if (this.connection) {
            await this.connection.end();
            console.log('🔌 数据库连接已关闭');
        }
    }

    // 加载JSON数据
    loadJsonData() {
        try {
            console.log('📄 正在加载基础物品JSON数据...');
            const jsonPath = path.join(__dirname, 'output', '基础物品_0911.json');

            if (!fs.existsSync(jsonPath)) {
                throw new Error(`JSON文件不存在: ${jsonPath}`);
            }

            const jsonContent = fs.readFileSync(jsonPath, 'utf8');
            this.jsonData = JSON.parse(jsonContent);

            console.log(`✅ JSON数据加载成功，共 ${Object.keys(this.jsonData).length} 条记录`);
        } catch (error) {
            console.error('❌ 加载JSON数据失败:', error.message);
            throw error;
        }
    }

    // 从JSON数据中提取物品名称和ID的映射
    extractJsonItems() {
        const jsonItems = new Map();

        for (const [id, itemData] of Object.entries(this.jsonData)) {
            if (itemData && itemData.data && Array.isArray(itemData.data)) {
                // 查找名称字段
                const nameField = itemData.data.find(field => field.k === '名称:');
                if (nameField && nameField.v) {
                    jsonItems.set(nameField.v.trim(), {
                        id: parseInt(id),
                        name: nameField.v.trim(),
                        data: itemData.data
                    });
                }
            }
        }

        console.log(`📊 从JSON中提取到 ${jsonItems.size} 个物品`);
        return jsonItems;
    }

    // 查询数据库中的basic_items表
    async getDatabaseItems() {
        try {
            console.log('🔍 正在查询数据库中的basic_items表...');
            const [rows] = await this.connection.execute(
                'SELECT id, name FROM basic_items ORDER BY id'
            );

            console.log(`✅ 数据库查询成功，共 ${rows.length} 条记录`);
            return rows;
        } catch (error) {
            console.error('❌ 查询数据库失败:', error.message);
            throw error;
        }
    }

    // 比较JSON和数据库，找出缺失的物品
    async findMissingItems() {
        try {
            // 提取JSON中的物品
            const jsonItems = this.extractJsonItems();

            // 查询数据库中的物品
            const dbItems = await this.getDatabaseItems();

            console.log('\n🔍 开始比较JSON和数据库...');
            console.log('=' * 60);

            // 创建数据库物品的Map
            const dbItemsMap = new Map();
            for (const item of dbItems) {
                dbItemsMap.set(item.name.trim(), item);
            }

            // 找出JSON中有但数据库中没有的物品
            const missingInDb = [];
            const extraInDb = [];

            for (const [name, jsonItem] of jsonItems) {
                if (!dbItemsMap.has(name)) {
                    missingInDb.push(jsonItem);
                }
            }

            // 找出数据库中有但JSON中没有的物品
            for (const [name, dbItem] of dbItemsMap) {
                if (!jsonItems.has(name)) {
                    extraInDb.push(dbItem);
                }
            }

            console.log(`\n📊 比较结果:`);
            console.log(`   JSON物品数量: ${jsonItems.size}`);
            console.log(`   数据库物品数量: ${dbItems.length}`);
            console.log(`   数据库缺失物品: ${missingInDb.length} 个`);
            console.log(`   数据库多余物品: ${extraInDb.length} 个`);

            if (missingInDb.length > 0) {
                console.log(`\n❌ 数据库缺失的物品:`);
                missingInDb.forEach(item => {
                    console.log(`   ID: ${item.id}, 名称: "${item.name}"`);

                    // 显示物品详细信息
                    console.log(`   详细信息:`);
                    item.data.forEach(field => {
                        console.log(`     ${field.k} ${field.v}`);
                    });
                    console.log('');
                });
            }

            if (extraInDb.length > 0) {
                console.log(`\n➕ 数据库多余的物品:`);
                extraInDb.forEach(item => {
                    console.log(`   ID: ${item.id}, 名称: "${item.name}"`);
                });
            }

            // 检查ID范围
            const jsonIds = Array.from(jsonItems.values()).map(item => item.id).sort((a, b) => a - b);
            const dbIds = dbItems.map(item => item.id).sort((a, b) => a - b);

            console.log(`\n📊 ID范围分析:`);
            console.log(`   JSON ID范围: ${Math.min(...jsonIds)} - ${Math.max(...jsonIds)}`);
            console.log(`   数据库ID范围: ${Math.min(...dbIds)} - ${Math.max(...dbIds)}`);

            // 找出缺失的ID
            const missingIds = [];
            for (const jsonId of jsonIds) {
                if (!dbIds.includes(jsonId)) {
                    missingIds.push(jsonId);
                }
            }

            if (missingIds.length > 0) {
                console.log(`\n🔍 缺失的ID: ${missingIds.join(', ')}`);
            }

            return {
                missingInDb,
                extraInDb,
                jsonCount: jsonItems.size,
                dbCount: dbItems.length
            };

        } catch (error) {
            console.error('❌ 比较过程中发生错误:', error.message);
            throw error;
        }
    }

    // 运行检查流程
    async runCheck() {
        console.log('🚀 开始检查缺失物品...\n');

        try {
            // 1. 连接数据库
            await this.connectDatabase();

            // 2. 加载JSON数据
            this.loadJsonData();

            // 3. 比较并找出缺失物品
            const result = await this.findMissingItems();

            console.log('\n🎉 检查完成！');

            return result;

        } catch (error) {
            console.error('💥 检查流程失败:', error.message);
            throw error;
        } finally {
            // 4. 关闭数据库连接
            await this.closeDatabase();
        }
    }
}

// 运行检查
async function main() {
    console.log('🎯 缺失物品检查工具');
    console.log('   目标：找出JSON中有但数据库中没有的物品\n');

    const checker = new MissingItemChecker();
    await checker.runCheck();
}

// 如果直接运行此脚本
if (require.main === module) {
    main().catch((error) => {
        console.error('💥 脚本执行失败:', error.message);
        process.exit(1);
    });
}

module.exports = MissingItemChecker;
